home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 23 / CU Amiga - Super CD-ROM 23 (June 1998).iso / CUCD / Sound / MPTool / MPTool.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-28  |  9.7 KB  |  386 lines
  1.  /* MPTool   -  First Step : 04/09/97 */
  2.  /*             Last Modif : 29/10/97 */
  3.  /* by HEINRICH Patrick               */
  4.  /* Nothing but a working version ;)  */
  5.  /* Frozen : V0.03                    */
  6.  
  7.  
  8. #include        <stdio.h>
  9. #include        <string.h>
  10. #include        <stdlib.h>
  11. #include        <dos/dos.h>
  12.  
  13. #define         VER     "0.03"
  14. #define         MESS1   " Usage : %s <Option> <Files |Dirs | Volumes>"
  15. #define         OPT1    "  <Option> :    t  <=>  simple time listing\n"
  16. #define         OPT2    "                c  <=>  time listing + duration/kbps in comment\n\n"
  17. #define         RET     printf("\n")
  18.  
  19.  /* def var */
  20.  
  21.     FILE *infp;
  22.     char *ptr;
  23.     char path [256];
  24.     long filesize=0;
  25.     long mpduration=0;
  26.     long mptotsize=0;
  27.     int filetot=0;
  28.     int dirtot=0;
  29.     int mptot=0;
  30.     int com=0;
  31.     int count=2;
  32.     struct FileInfoBlock *fib3_ptr;
  33.     struct FileLock *File3Lock ;
  34.  
  35.  
  36.  /* end def */
  37.  
  38.  
  39.  /* def func */
  40.  
  41.     void ExamineIt(char* File2Lock);
  42.     void IsMPEG(char* gimmefile,long zisize);
  43.  
  44.  /* end def */
  45.  
  46.  
  47. main(int argc, char *argv[])
  48.  
  49. {
  50.     printf("\n%c[1;31m MPTool %c[0mV%s '97 by %c[1;32m·HEINRICH Patrick·%c[0m \n",27,27,VER,27,27);
  51.     printf("\n Registered to : %c[0;33mEverybody%c[0m \n\n",27,27);
  52.  
  53.     if (argc < 3) { printf(MESS1,argv[0]);RET;RET;printf(OPT1);printf(OPT2);exit(0); }
  54.  
  55.     switch (*argv[1])
  56.  
  57.     {
  58.  
  59.     case 'c':case'C':
  60.  
  61.     com=1;
  62.  
  63.     case 't':case'T':
  64.  
  65.  
  66.  
  67.     /* is argv[count] a directory/file/volume */
  68.  
  69.     for ( count=2; (count<=(argc-1)) ;count++ )
  70.  
  71.     {
  72.  
  73.     JumpIn:
  74.  
  75.     strcpy(path,argv[count]);
  76.     ptr=path;
  77.     while ((*ptr!=':') && (*ptr!=0)) {ptr++;} ptr++;
  78.     if (*ptr!=0)
  79.                     {
  80.                     while (*ptr!=0) {ptr++;}
  81.                     ptr--;
  82.                     if (*ptr!='/') {} else {*ptr=0;}
  83.                     }
  84.  
  85.     fib3_ptr = AllocMem( sizeof( struct FileInfoBlock ),0 );
  86.  
  87.     File3Lock = Lock( path, -2 );
  88.     if ( File3Lock  == NULL ) {printf("\n Can't lock file %s\n",File3Lock);}
  89.  
  90.     Examine(File3Lock,fib3_ptr);
  91.  
  92.     if ((*fib3_ptr).fib_DirEntryType<0)
  93.             {
  94.             filesize=(*fib3_ptr).fib_Size;
  95.             IsMPEG(argv[count],filesize);
  96.             UnLock(File3Lock);
  97.             FreeMem( fib3_ptr, sizeof( struct FileInfoBlock ) );
  98.             count++;
  99.             filetot++;
  100.             if (count<=argc-1) goto JumpIn;
  101.             goto EndPart;
  102.             }
  103.  
  104.  
  105.     UnLock(File3Lock);
  106.     FreeMem( fib3_ptr, sizeof( struct FileInfoBlock ) );
  107.  
  108.  
  109.     if (argc==3)
  110.  
  111.         {
  112.         printf("\n============================[MPTool]===['97·TMG·]===============================\n\n");
  113.         printf("    MPTool was started from %s\n",path);
  114.         }
  115.         printf("\n============================[MPTool]===['97·TMG·]===============================\n\n");
  116.  
  117.  
  118.     ExamineIt(path);
  119.     }
  120.  
  121.     EndPart:
  122.  
  123.     printf("\n============================[MPTool]===['97·TMG·]===============================\n");
  124.     if (argc==3) printf("\n %s \n",path);
  125.     printf("\n                         %12i Files\n",filetot);
  126.     printf("                         %12i Directories\n",dirtot);
  127.     printf("                         %12i MPEG Files\n",mptot);
  128.     if (mptotsize/(1024*1024) >= 2)
  129.     printf("\n                         %12d Mbs of MPEG\n",mptotsize/(1024*1024));
  130.     printf("                         %12d Kbs of MPEG\n",mptotsize/1024);
  131.     printf("                         %12d bytes of MPEG\n",mptotsize);
  132.     printf("\n                             %02i:%02i:%02i Total Duration\n",(mpduration/3600),((mpduration-3600*(mpduration/3600))/60),mpduration-3600*(mpduration/3600)-60*((mpduration-3600*(mpduration/3600))/60));
  133.     printf("\n============================[MPTool]===['97·TMG·]===============================\n\n");
  134.  
  135.     break;
  136.  
  137.     default:
  138.  
  139.     RET;printf(MESS1,argv[0]);RET;RET;printf(OPT1);printf(OPT2);exit(0);
  140.  
  141.  
  142.     }
  143.  
  144.  
  145. }
  146.  
  147.  
  148. void ExamineIt(char* File2Lock)
  149.  
  150.     {
  151.     int count=0;            /* check 4 dir */
  152.     int fromvol=1;          /* check for a lone volume */
  153.     long size=0;
  154.     char newpath [256];
  155.     char newpass [256];
  156.     char* carptr;
  157.     struct FileInfoBlock *fib_ptr;
  158.     struct FileLock *File1Lock ;
  159.  
  160.  
  161.     fib_ptr = AllocMem( sizeof( struct FileInfoBlock ),0 );
  162.  
  163.     strcpy(newpath,File2Lock);
  164.     carptr=newpath;
  165.  
  166.     while (*carptr!=':') {carptr++;} carptr++;
  167.     if (*carptr!=0) {fromvol=0;}
  168.  
  169.     if( fib_ptr == NULL ) { printf("\n Not Enough Memory \n");exit(0); }
  170.  
  171.     File1Lock = Lock( File2Lock, -2 );
  172.     if ( File1Lock  == NULL ) {printf("\n Can't lock file %s\n",File2Lock);}
  173.  
  174.     Examine(File1Lock,fib_ptr);
  175.  
  176.     while (ExNext(File1Lock,fib_ptr))
  177.  
  178.         {
  179.         if ( ((*fib_ptr).fib_DirEntryType>0) && (fib_ptr!=NULL) )
  180.              {
  181.                dirtot++;
  182.                if (count!=0)
  183.                     {
  184.                     if (fromvol==1)
  185.                         {
  186.                         strcpy(newpath,File2Lock);
  187.                         strcat(newpath,(*fib_ptr).fib_FileName);
  188.                         }
  189.                     else
  190.                         {
  191.                         strcpy(newpath,File2Lock);strcat(newpath,"/");
  192.                         strcat(newpath,(*fib_ptr).fib_FileName);
  193.                         }
  194.                     }
  195.                else
  196.                     {
  197.                     if (fromvol==1)
  198.                         {
  199.                         strcat(newpath,(*fib_ptr).fib_FileName);
  200.                         }
  201.                     else
  202.                         {
  203.                         strcat(newpath,"/");
  204.                         strcat(newpath,(*fib_ptr).fib_FileName);
  205.                         }
  206.                     }
  207.                ExamineIt(newpath);
  208.                count++;
  209.              }
  210.  
  211.  
  212.         else {
  213.                filetot++;
  214.                size=(*fib_ptr).fib_Size;
  215.                strcpy(newpass,File2Lock);
  216.                if (fromvol==1)
  217.                     {
  218.                     IsMPEG(strcat(newpass,(*fib_ptr).fib_FileName),size);
  219.                     }
  220.                else
  221.                     {
  222.                     strcat(newpass,"/");
  223.                     IsMPEG(strcat(newpass,(*fib_ptr).fib_FileName),size);
  224.                     }
  225.              }
  226.         }
  227.     UnLock(File1Lock);
  228.     FreeMem( fib_ptr, sizeof( struct FileInfoBlock ) );
  229.     }
  230.  
  231. void IsMPEG(char* gimmefile,long zisize)
  232.  
  233.     {
  234.     FILE *infp;
  235.     unsigned char inc;
  236.     char *pointer;
  237.     int kbps=0;
  238.     char commy [80];
  239.     char temp [10];
  240.     long tmpsize;
  241.  
  242.     tmpsize=zisize;
  243.  
  244.     infp=fopen(gimmefile,"rb");
  245.  
  246.     if (infp==NULL)
  247.  
  248.         {
  249.         printf("\n Can't open file %s\n Check the path & filename\n\n",gimmefile);
  250.         return;
  251.         }
  252.  
  253.     inc=fgetc(infp);
  254.  
  255.     if ( inc!=255 )
  256.  
  257.         {
  258.         return;
  259.         }
  260.  
  261.     inc=fgetc(infp);
  262.  
  263.     if (!( (inc==251) || (inc == 242) || (inc==250) || (inc==252)))
  264.  
  265.         {
  266.         return;
  267.         }
  268.  
  269.  
  270.     if ((inc==250) || (inc==251))
  271.  
  272.       { inc=fgetc(infp);
  273.  
  274.         switch (inc)
  275.  
  276.         {
  277.  
  278.         case 16:    kbps=32;break;
  279.         case 32:    kbps=40;break;
  280.         case 48:    kbps=48;break;
  281.         case 64:    kbps=56;break;
  282.         case 80:    kbps=64;break;
  283.         case 96:    kbps=80;break;
  284.         case 112:   kbps=96;break;
  285.         case 128:   kbps=112;break;
  286.         case 144:   kbps=128;break;
  287.         case 160:   kbps=160;break;
  288.         case 176:   kbps=192;break;
  289.         case 192:   kbps=224;break;
  290.         case 208:   kbps=256;break;
  291.         case 224:   kbps=320;break;
  292.  
  293.         default: kbps=128;break;
  294.         }
  295.       }
  296.  
  297.      else
  298.  
  299.       {
  300.  
  301.         if (inc==252)
  302.  
  303.             { inc=fgetc(infp);
  304.  
  305.             switch (inc)
  306.  
  307.             {
  308.  
  309.             case 16:    kbps=32;break;
  310.             case 32:    kbps=48;break;
  311.             case 48:    kbps=56;break;
  312.             case 64:    kbps=64;break;
  313.             case 80:    kbps=80;break;
  314.             case 96:    kbps=96;break;
  315.             case 112:   kbps=112;break;
  316.             case 128:   kbps=128;break;
  317.             case 144:   kbps=168;break;
  318.             case 160:   kbps=192;break;
  319.             case 176:   kbps=224;break;
  320.             case 192:   kbps=256;break;
  321.             case 208:   kbps=320;break;
  322.             case 224:   kbps=384;break;
  323.  
  324.             default: return;
  325.             }
  326.             }
  327.          else {
  328.                 if (inc==242)
  329.  
  330.                     { inc=fgetc(infp);
  331.  
  332.                     switch (inc)
  333.  
  334.                     {
  335.  
  336.                     case 16:    kbps=8;break;
  337.                     case 32:    kbps=16;break;
  338.                     case 48:    kbps=24;break;
  339.                     case 64:    kbps=32;break;
  340.                     case 80:    kbps=40;break;
  341.                     case 96:    kbps=48;break;
  342.                     case 112:   kbps=56;break;
  343.                     case 128:   kbps=64;break;
  344.                     case 144:   kbps=80;break;
  345.                     case 160:   kbps=96;break;
  346.                     case 176:   kbps=112;break;
  347.                     case 192:   kbps=128;break;
  348.                     case 208:   kbps=144;break;
  349.  
  350.                     default:return;
  351.                     }
  352.                     }
  353.                  else {return;}
  354.                }
  355.  
  356.       }
  357.  
  358.     mpduration=mpduration+(8*zisize/1000/kbps);
  359.     printf(" %-65.65s %0.2ld:%0.2ld %3ikbps\n",gimmefile,(8*zisize/1000/kbps/60),(8*zisize/1000/kbps)-(8*zisize/1000/kbps/60)*60,kbps);
  360.  
  361.     if (com==1)
  362.         {
  363.         if ((8*zisize/1000/kbps/60)<10) {strcpy(commy," [0");} else {strcpy(commy," [");}
  364.  
  365.         stci_d(temp,(8*zisize/1000/kbps/60));
  366.         strcat(commy,temp);
  367.         strcat(commy,":");
  368.  
  369.         zisize=((8*zisize/1000/kbps)-(8*zisize/1000/kbps/60)*60);
  370.  
  371.         if ( zisize <10 ) {strcat(commy,"0");}
  372.  
  373.         stci_d(temp,zisize);
  374.         strcat(commy,temp);
  375.         strcat(commy,"] - [");
  376.         stci_d(temp,kbps);
  377.         strcat(commy,temp);
  378.         strcat(commy,"kbps]");
  379.  
  380.         SetComment(gimmefile , commy);
  381.         }
  382.  
  383.     mptot++;
  384.     mptotsize=mptotsize+tmpsize;
  385.     }
  386.